#!/usr/bin/perl
package genutil;
	$VERSION = '0.1';
	require Exporter;
	BEGIN {
	    @ISA = qw(Exporter);
	    @EXPORT = qw(
						DEBUG 
						OUT 
						addNamesToParameters 
						cicloGenerazioneStringheHash 
						cicloGenerazioneStringhe 
						evalPerl 
						isEqual 
						isEmpty 
						isNotEmpty 
						src2dst_string 
						src2dst_file 
						interpolazioneStringaConHash 
						wordsInUpperCase 
						javaClassName 
						javaObjectName 
						plsqlName 
						dbTableName 
						javaPackageName 
						xmlName );
	}


#------------------------------------------------------
#	Output e debug
#------------------------------------------------------
sub DEBUG {
	my ($out) =@_;
	print ($out);
}
#------------------------------------------
sub OUT {
	my ($out) =@_;
	print ($out);
}
 
##########################################
#		GENERAZIONE CODICI
#		Funzioni di utilità richiamate dalla parte di generazione di codici
##########################################

#------------------------------------------------------
#	Aggiunta dei nomi dei parametri trasformati
#------------------------------------------------------
sub addNamesToParameters {
	my ($k, $valore, $p) = @_;

	my $nome;
	$nome = javaPackageName( $k );	$p->{$nome}=javaPackageName( $valore );
	$nome = javaClassName( $k );	$p->{$nome}=javaClassName( $valore );
	$nome = javaObjectName( $k );	$p->{$nome}=javaObjectName( $valore );
	return $p;
}



sub cicloGenerazioneStringheHash {
	# ciclo standard di generazione di una stringa. Tipicamente utilizzato per gli argomenti e attributi
	# che devono essere specificati con l'hash %a e non con %p. Esempio di gen:
	# 	<gen name="crud:XXX" type="cicle", hash="$p{yyy}">
	my( $asArg, $comando, $p ) = @_; 
	my %p=%$p; my $out='';
											#print Dumper( $p ); die(1);
	my @keys = sort { $a <=> $b } keys( %$asArg );
	my $length = @keys;
							###########DEBUG my $fp = $p->{form}; 	my @keys = sort { $a <=> $b } keys( %$fp );	
	foreach $i (@keys){
		my $a = $asArg->{$i};
		my %a = %$a;
		
		#print Dumper( $a ); die($comando);
		
		my $str;
		eval( $comando );
		$out .= $str;
	}
#die( $out );
	return $out;
}
#--------------------------------


sub cicloGenerazioneStringhe {
	# ciclo standard di generazione di una stringa. 
	# $arr = array di hash (Tipicamente utilizzato per gli argomenti e attributi) che devono essere specificati con l'hash %a e non con %p. 
	# $comando=comando che valorizza una stringa $str. In comando, ci si aspetta l'i-esimo hash � %a
	# $p = parametri globali
	my( $arr, $comando, $p ) = @_; 
	my %p=%$p; my $out='';
	my @ar = @$arr;
	my $length = @ar;
	for( $i=0; $i < $length; $i++ ){
		my $a =  $ar[$i];		
		my %a = %$a;
		
		#print Dumper( $a ); die($comando);
		
		my $str='';;
		eval( $comando );
		$out .= $str;
	}
	#die( $out );
	return $out;
}
#--------------------------------

sub evalPerl {
	my ($perlCode, $comment)= @_;
	eval( $perlCode ); 
	if ($@ ne "")  {
		if( $comment ne '' ){
			$comment = "comment:\n$comment\n";
		}
		die( "error on eval().\nerror: $@\n\n$comment" );
	}
}

#----------------------------------------
#	Boolean
#	usato per non avere warning con stringhe undef   
#----------------------------------------

sub isEqual {
	my ($str, $value) = @_;
	$str .= '';
	return ( $str eq $value );
}
sub isNotEqual {
	my ($str, $value) = @_;
	$str .= '';
	return ( $str ne $value );
}
sub isEqualRegExp {
	my ($str, $value) = @_;
	$str .= '';
	return ( $str =~ /$value/ );
}
sub isNotEqualRegExp {
	my ($str, $value) = @_;
	return !( isEqualRegExp($str, $value) );
}
sub isEmpty {
	my ($str, $value) = @_;
	$str .= '';
	return isEqual( $str, '' );
}
sub isNotEmpty {
	my ($str, $value) = @_;
	$str .= '';
	return isNotEqual( $str, '' );
}
#----------------------------------------
#	SOSTITUZIONI
#----------------------------------------

sub src2dst_string {
	#prende l'hash delle sostituzioni, e trasforma 
	#	$sost{i}{src}  in $sost{i}{dst} 
	# nella stringa $str
	my ($srcHash, $dstHash, $str ) = @_;
	foreach my $s (keys(%$srcHash)) {
		my $src = $srcHash->{$s};
		my $dst = $dstHash->{$s};
		$str =~ s/$src/$dst/gm;
		#DEBUG( qq|sostituisci: my ($regexp, $sost, $file ) \n| );
	}
	return $str;
}

sub src2dst_file {
	my ($srcHash, $dstHash, $file ) = @_;
	open( F, "$file" ); my @righe = <F>; close(F);

	open( F, ">$file" );
	foreach $r (@righe)	{
		$r = src2dst_string( $srcHash, $dstHash, $r );
		print F $r;
	}
	close(F);
	DEBUG("$file\n")
}

sub interpolazioneStringaConHash {
	#la stringa deve contenere nomi con una hash %p.
	#esempio: $p{dir}/pippo/pluto/$p{NomeEntita}Action.java 
	my( $strConVariabili, $p ) = @_;
	my %p = %$p;

	my $str;
	$comando = "\$str=qq|$strConVariabili|;"; 		
	eval( $comando );			
	return $str;
}
#----------------------------------------


#------------------------------------------------------
#	FUNZIONI DI TRASFORMAZIONE DEI NOMI
#------------------------------------------------------

#
#	Trasforma 'nOMe ENTita' in 'Nome Entita'
#
sub wordsInUpperCase {
	my ($strIn) =@_;
	my @words = split(/ /,$strIn);
	my $str='';
	foreach $w (@words){
		$w = uc( substr( $w, 0, 1 )) . lc(substr( $w, 1 ));
		$str .= "$w ";
	}
	return $str;	
}
#
#	Trasforma 'nOMe ENTita' in 'NomeEntita'
#
sub javaClassName {
	my ($strIn) =@_;
	my $w=wordsInUpperCase($strIn);
	$w =~ s/ //g;
	$w = uc( substr( $w, 0, 1 )) . substr( $w, 1 );
	return $w;	
}
#
#	Trasforma 'nOMe ENTita' in 'nomeEntita'
#
sub javaObjectName {
	my ($strIn) =@_;
	my $w=javaClassName($strIn);
	$w = lc( substr( $w, 0, 1 )) . substr( $w, 1 );
	return $w;	
}
#
#	Trasforma 'nOMe ENTita' in 'nome_entita'
#
sub plsqlName {
	my ($strIn) =@_;
	my $w = $strIn;
	$w =~ s/ /\_/g;
	$w = lc( $w );
	return $w;	
}
#
#	Trasforma 'nOMe ENTita' in 'NOME_ENTITA'
#
sub dbTableName {
	my ($strIn) =@_;
	my $w = $strIn;
	$w =~ s/ //g;
	$w = uc( $w );
	return $w;	
}
#
#	Trasforma 'nOMe ENTita' in 'nomeentita'
#
sub javaPackageName {
	my ($strIn) =@_;
	my $w = $strIn;
	$w =~ s/ //g;
	$w = lc( $w );
	return $w;	
}
#
#	Trasforma 'nOMe ENTita' in 'nome-entita'
#
sub xmlName {
	my ($strIn) =@_;
	my $w = $strIn;
	$w =~ s/ /\-/g;
	$w = lc( $w );
	return $w;	
}

1;
